home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Sound / Subspace68k / src / Deltafields.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-04  |  5.1 KB  |  263 lines
  1.  
  2. #include <exec/types.h>
  3. #include <math.h>
  4.  
  5. #ifdef __SASC
  6.     #define M_PI PI
  7. #endif
  8. #ifdef __VBCC__
  9. #define   M_PI 3.14159265358979323846
  10. #endif
  11.  
  12. float rnd(float max);
  13. float sgn(float val);
  14. float trnc(float value);
  15.  
  16. extern ULONG TimeWave;
  17. extern ULONG LineToCalc;
  18. extern WORD     *PluginSamples;
  19.  
  20. float A0, A1, A2, A3, A4, A5, A6, A7, A8, A9;
  21.  
  22. void PrepareConstants(UBYTE FieldNum) {
  23.     switch(FieldNum) {
  24.         case 0:
  25.         break;
  26.         case 1:
  27.         break;
  28.         case 2:
  29.         break;
  30.         case 3:
  31.         break;
  32.         case 4:
  33.             A0 = rnd(M_PI);
  34.             A1 = .01*(.5 + rnd(.5) + rnd(.5));
  35.             A2 =  .1*(.5 + rnd(.5) + rnd(.5));
  36.         break;
  37.         case 5:
  38.         break;
  39.         case 6:
  40.         break;
  41.         case 7:
  42.             A0 = 2    + rnd(30);
  43.             A1 = 0.01 + rnd(0.05);
  44.         break;
  45.         case 8:
  46.             A0 = 14;
  47.             A1 = 0.08;
  48.             A2 = 3 + rnd(3);
  49.             A3 = 0.01;
  50.         break;
  51.         case 9:
  52.         break;
  53.         case 10: // Radial Breakaway
  54.         break;
  55.         case 11: // SOLs Waves
  56.         break;
  57.         case 12: // SOLs Growth Formula
  58.             A0 = 2.0 * ( 2.0 + rnd(12));
  59.             A1 = 0.01 + rnd(0.03);
  60.         break;
  61.         case 13: // Tiles
  62.             A0 = 1.90  * (1.0 + rnd(2.0));
  63.             A1 = 0.005 * (1.0 + rnd(1.0));
  64.         break;
  65.         case 14: // In or out, inner Turn
  66.             A0 = 0.95 + rnd(.06);
  67.         break;
  68.         case 15: // Slidering
  69.             A0 = 8.0  + rnd(16);
  70.             A1 = 0.03 + rnd(.05);
  71.             A2 = (0.006 + rnd( .006 )) * sgn(0.5-rnd(1.0));
  72.             A3 = A0 / 2.0;
  73.         break;
  74.         case 16: // Sine Multi-Circ
  75.         break;
  76.         case 17: // Noise
  77.         break;
  78.  
  79.         case 18: // The MAW
  80.         break;
  81.     }
  82. }
  83.  
  84. void CalcLine(LONG *Zoom, ULONG Width, ULONG Height, UBYTE FieldNum) {
  85.     LONG i,xs,ys,xd,yd;
  86.  
  87.     float scale,greater;
  88.     float xsf,ysf,xdf,ydf;
  89.     float rsf,tsf,rdf,tdf;
  90.     float wf,hf;
  91.  
  92.     wf=(float)Width;
  93.     hf=(float)Height;
  94.  
  95.     greater=1.0;
  96.     if(wf > greater) greater = wf;
  97.     if(hf > greater) greater = hf;
  98.  
  99.     scale = 1.0 / (greater/2.0);
  100.  
  101.     yd = LineToCalc;
  102.     for(xd=0; xd<(Width); xd++) {
  103.         xdf = (xd - wf/2.0) * scale;
  104.         ydf = (yd - hf/2.0) * scale;
  105.  
  106.         switch(FieldNum) {
  107.             case 0:
  108.                 xsf = xdf - xdf * 0.075;
  109.                 ysf = ydf - ydf * 0.075;
  110.             break;
  111.  
  112.             case 1:
  113.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  114.                 tdf = atan2(ydf, xdf);
  115.                 rsf = rdf - .015;
  116.                 tsf = tdf + .02;
  117.                 xsf = rsf * cos(tsf);
  118.                 ysf = rsf * sin(tsf);
  119.             break;
  120.  
  121.             case 2:
  122.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  123.                 tdf = atan2(ydf, xdf);
  124.                 rsf = rdf - .015;
  125.                 tsf = tdf - .02;
  126.                 xsf = rsf * cos(tsf);
  127.                 ysf = rsf * sin(tsf);
  128.             break;
  129.  
  130.             case 3:
  131.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  132.                 tdf = atan2(ydf, xdf);
  133.                 rsf = rdf - .04;
  134.                 tsf = tdf - .005;
  135.                 xsf = rsf * cos(tsf);
  136.                 ysf = rsf * sin(tsf);
  137.             break;
  138.  
  139.             case 4: {
  140.                 float d0;
  141.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  142.                 tdf = atan2(ydf, xdf);
  143.  
  144.                 d0  = 2.0 * tdf + 6.28 * rdf + A0;
  145.                 rsf = rdf + A1 * cos(d0);
  146.                 tsf = tdf + A2 * sin(d0);
  147.  
  148.                 xsf = rsf * cos(tsf);
  149.                 ysf = rsf * sin(tsf);
  150.             }
  151.             break;
  152.  
  153.             case 5:
  154.                 xsf = xdf * .97;
  155.                 if(ydf < 0.0) ysf = ydf + (cos((pow(ydf+1,2.7)  ) * 10) + 1.4) / 40;
  156.                 else          ysf = ydf - (cos((pow(ydf+1,2.7)  ) * 10) + 1.4) / 40;
  157.             break;
  158.  
  159.             case 6:
  160.                 xsf = xdf + ydf / 8.0;
  161.                 ysf = ydf - xdf / 90.0;
  162.             break;
  163.  
  164.             case 7:
  165.                 xsf = xdf + A1 * sin(A0*ydf);
  166.                 ysf = ydf + A1 * sin(A0*xdf);
  167.             break;
  168.  
  169.             case 8:
  170.                 xsf = xdf + A1 * sin(A2*ydf);
  171.                 ysf = ydf + A3 * sin(A0*xdf);
  172.             break;
  173.  
  174.             case 9:
  175.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  176.                 tdf = atan2(ydf, xdf);
  177.                 rsf = sin(rdf);
  178.                 tsf = tdf - ((rdf - 0.042) * rnd (0.09));
  179.                 xsf = rsf * cos(tsf);
  180.                 ysf = rsf * sin(tsf);
  181.             break;
  182.  
  183.             case 10: // Radial Breakaway
  184.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  185.                 tdf = atan2(ydf, xdf);
  186.                 rsf = rdf * (1.0+0.16*atan(0.55-rdf));
  187.                 tsf = tdf - 0.01;
  188.                 xsf = rsf * cos(tsf);
  189.                 ysf = rsf * sin(tsf);
  190.             break;
  191.  
  192.             case 11: // SOLs Waves
  193.                 xsf = xdf * 0.97;
  194.                 ysf = ydf - (cos(pow(ydf+1.0, 2.7)*10) + 1.5) / 40.0;
  195.             break;
  196.  
  197.             case 12: // SOLs Growth Formula
  198.                 xsf = xdf + A1 * cos(A0*xdf);
  199.                 ysf = ydf + A1 * cos(A0*ydf);
  200.             break;
  201.  
  202.             case 13: // Tiles
  203.                 xsf = xdf + A1 * (2.0 * (fmod(((ydf+1) * A0), 2.0)) - 1.0);
  204.                 ysf = ydf + A1 * (2.0 * (fmod(((xdf+1) * A0), 2.0)) - 1.0);
  205.             break;
  206.  
  207.             case 14: // In or out, inner Turn
  208.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  209.                 tdf = atan2(ydf, xdf);
  210.                 rsf = rdf * A0;
  211.                 tsf = tdf - fabs(1.0-rdf) * 0.035;
  212.                 xsf = rsf * cos(tsf);
  213.                 ysf = rsf * sin(tsf);
  214.             break;
  215.  
  216.             case 15: // Slidering
  217.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  218.                 tdf = atan2(ydf, xdf);
  219.                 rsf = fabs(rdf + A1*sin(A0*rdf));
  220.                 tsf = tdf - (A2*sgn(sin(A3*rdf)));
  221.                 xsf = rsf * cos(tsf);
  222.                 ysf = rsf * sin(tsf);
  223.             break;
  224.  
  225.             case 16: // Sine Multi-Circ
  226.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  227.                 tdf = atan2(ydf, xdf);
  228.                 rsf = rdf * (0.87 + 0.05 * (1.0+sin(rdf * 15)));
  229.                 tsf = tdf;
  230.                 xsf = rsf * cos(tsf);
  231.                 ysf = rsf * sin(tsf);
  232.             break;
  233.  
  234.             case 17: // Noise
  235.                 xsf = xdf + rnd(0.11) - 0.055;
  236.                 ysf = ydf + rnd(0.11) - 0.055;
  237.             break;
  238.  
  239.             case 18: // The MAW
  240.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  241.                 tdf = atan2(ydf, xdf);
  242.                 rsf = rdf + 0.0119; 
  243.                 tsf = tdf - (0.055 * ( rdf - 0.324 ) ) * ( rdf + 0.279 );
  244.                 xsf = rsf * cos(tsf);
  245.                 ysf = rsf * sin(tsf);
  246.             break;
  247.         }
  248.  
  249.         xs = xsf/scale + wf/2.0;
  250.         ys = ysf/scale + hf/2.0;
  251.  
  252.         if(xs < Width/2)  xs++;
  253.         if(ys < Height/2) ys++;
  254.  
  255.         if(xs < 0)      xs = 0;
  256.         if(xs > Width)  xs = Width;
  257.         if(ys < 0)      ys = 0;
  258.         if(ys > Height) ys = Height;
  259.  
  260.         Zoom[Width * yd + xd] = Width * ys + xs;
  261.     }
  262. }
  263.